详解Java中的装饰器

本文介绍装饰器模式，并通过示例来阐述装饰器模式的实现方法和在Spring中使用装饰器，希望对读者了解装饰器有所帮助。

长按关注《Java学研大本营》

1 简介

装饰器模式是一种结构型设计模式，它允许在运行时动态地扩展对象的行为，不用修改原始对象的代码。它通过将对象包装在一个包装器类中来实现这一点，该包装器类具有与原始对象相同的接口，并且在委托给原始对象之前或之后添加额外的行为。

装饰器模式通常用于以下两种情况：

• 当需要在不修改现有代码的情况下添加新功能或修改现有功能时。
• 当需要使用许多独立的扩展来实现不同的组合时。

2 装饰器模式的实现

我们通过一个示例来看看它是如何实现的。在下面的示例中，我们将实现一个BoundedSet——Java中大小限制的集合。

public abstract class ForwardingSet<T> implements Set<T> {

    public abstract Set<T> delegate();

    @Override
    public int size() {
        return delegate().size();
    }

    @Override
    public boolean isEmpty() {
        return delegate().isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return delegate().contains(o);
    }

    @Override
    public Iterator<T> iterator() {
        return delegate().iterator();
    }

    @Override
    public Object[] toArray() {
        return delegate().toArray();
    }

    @Override
    public <T1> T1[] toArray(T1[] a) {
        return delegate().toArray(a);
    }

    @Override
    public boolean add(T t) {
        return delegate().add(t);
    }

    @Override
    public boolean remove(Object o) {
        return delegate().remove(o);
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return delegate().containsAll(c);
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        return delegate().addAll(c);
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return delegate().retainAll(c);
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return delegate().removeAll(c);
    }

    @Override
    public void clear() {
        delegate().clear();
    }

}

ForwardingSet是受Google Guava库中的ForwardingSet启发而来的。这个集合只是将其所有方法调用委托给底层委托对象，这是一种组合关系。委托是指我们将所有的调用都派发到底层对象进行处理，而在处理之前可以修改其行为。现在，我们可以继承这个类并覆盖任何方法以修改它们的行为，就像我们在BoundedSet中所做的那样。

@ThreadSafe
public class BoundedSet<T> extends ForwardingSet<T> {

    private Set<T> set;
    private Semaphore semaphore;

    public BoundedSet(int bound) {
        this.semaphore = new Semaphore(bound);
        this.set = Collections.synchronizedSet(new HashSet<>());
    }

    @Override
    public boolean add(T t) {
        try {
            semaphore.acquire();
            boolean wasAdded = super.add(t);
            if (!wasAdded) {
                semaphore.release();
            }
            return wasAdded;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public boolean remove(Object o) {
        boolean wasRemoved = super.remove(o);
        if (wasRemoved) {
            semaphore.release();
        }
        return wasRemoved;
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        try {
            boolean setChanged = false;
            for(var e : c) {
                semaphore.acquire();
                boolean wasAdded = super.add(e);
                if(!wasAdded) {
                    semaphore.release();
                }
                setChanged |= wasAdded;
            }
            return setChanged;
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        boolean setChanged = false;
        for(var e : c) {
            boolean wasRemoved = super.remove(e);
            if(wasRemoved) {
                semaphore.release();
            }
            setChanged |= wasRemoved;
        }
        return setChanged;
    }

    @Override
    public Set<T> delegate() {
        return this.set;
    }

}

在这里，我们修改了add、remove、addAll和removeAll方法的行为。对于每个add，我们从信号量中获取一个许可。对于每个remove，我们添加一个许可。由于在这里使用的是不可扩展的同步集合，因此实现有点简单，但是您可以理解其思想。要使用这个类，请执行以下操作：

Set<Integer> set = new BoundedSet<>(10);

3 在Spring中使用装饰器的例子

在Spring中，装饰器大量用于在进入对象之前拦截对它们的调用。在我们的情况下，我们必须解决Java中线程切换时在两个线程之间传输MDC的棘手问题。MDC是一种在日志记录期间传输上下文信息的机制，例如请求ID或用户ID等信息。我们通过装饰相应执行器服务的submit方法来解决这个问题，以获取调用线程的MDC，将其复制到当前线程的MDC（在runnable内部），然后将调用派发到底层委托。以下是代码：

ForwardedExecutorService.java

public abstract class ForwardedExecutorService implements ExecutorService {

    public abstract ExecutorService delegate();

    @Override
    public void shutdown() {
        delegate().shutdown();
    }

    @Override
    public List<Runnable> shutdownNow() {
        return delegate().shutdownNow();
    }

    @Override
    public boolean isShutdown() {
        return delegate().isShutdown();
    }

    @Override
    public boolean isTerminated() {
        return delegate().isTerminated();
    }

    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
        return delegate().awaitTermination(timeout, unit);
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        return delegate().submit(task);
    }

    @Override
    public <T> Future<T> submit(Runnable task, T result) {
        return delegate().submit(task, result);
    }

    @Override
    public Future<?> submit(Runnable task) {
        return delegate().submit(task);
    }

    @Override
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
        return delegate().invokeAll(tasks);
    }

    @Override
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException {
        return delegate().invokeAll(tasks, timeout, unit);
    }

    @Override
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
        return delegate().invokeAny(tasks);
    }

    @Override
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        return delegate().invokeAny(tasks, timeout, unit);
    }

    @Override
    public void execute(Runnable command) {
        delegate().execute(command);
    }
}

MDCAwareExecutorService.java

public class MDCAwareExecutorService extends ForwardedExecutorService {

    private ExecutorService es;

    public MDCAwareExecutorService() {
        this.es = Executors.newCachedThreadPool();
    }

    @Override
    public ExecutorService delegate() {
        return this.es;
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        return super.submit(decorateTask(task));
    }

    @Override
    public <T> Future<T> submit(Runnable task, T result) {
        return super.submit(decorateTask(task), result);
    }

    @Override
    public Future<?> submit(Runnable task) {
        return super.submit(decorateTask(task));
    }

    @Override
    public void execute(Runnable command) {
        super.execute(decorateTask(command));
    }

    private <V> Callable<V> decorateTask(Callable<V> task) {
        //获取当前线程的MDC
        Map<String, String> mdc = MDC.METADATA.get();
        return () -> {
            MDC.METADATA.set(mdc);
            return task.call();
        };
    }

    private Runnable decorateTask(Runnable task) {
        //获取当前线程的MDC
        Map<String, String> mdc = MDC.METADATA.get();
        return () -> {
            MDC.METADATA.set(mdc);
            task.run();
        };
    }
}

MDC.java

public class MDC {
    public static ThreadLocal<Map<String, String>> METADATA = new ThreadLocal<>();
}

Driver.java

public class Driver {
    public static void main(String[] args) throws InterruptedException {
        MDC.METADATA.set(Map.of("k1","v1","k2","v2"));
        var es = new MDCAwareExecutorService();
        es.submit(() -> {
            System.out.println("Thread: " + Thread.currentThread().getName() + ", MDC: " + MDC.METADATA.get());;
        });
        Thread.sleep(Integer.MAX_VALUE);
    }
}

推荐书单

《Java编程讲义》

《Java编程讲义》根据目前Java开发领域的实际需求，从初学者角度出发，详细讲解了Java技术的基础知识。全书共15章，包括Java开发入门，Java语言基础，Java控制结构，数组，面向对象编程，继承和多态，抽象类、接口和内部类，异常处理，Java常用类库，集合与泛型，Lambda表达式，输入-输出流，多线程，JDBC数据库技术，网络编程等内容。内容全面覆盖．1ava开发必备的基础知识点，结合生活化案例展开讲解，程序代码给出了详细的注释，能够使初学者轻松领会Java技术精髓，快速掌握Java开发技能。 《Java编程讲义》适合作为高等院校相关专业的教材及教学参考书，也适合作为Java开发入门者的自学用书，还可供开发人员查阅、参考。

购买链接：https://item.jd.com/13495830.html

精彩回顾

长按关注《Java学研大本营》

长按访问【IT今日热榜】，发现每日技术热点